home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 8 / The Arsenal Files Collection #8 (Arsenal Computer) (1996).ISO / g_quake / advqcc.zip / PR_COMP.C < prev    next >
C/C++ Source or Header  |  1996-09-26  |  22KB  |  934 lines
  1.  
  2. #include "qcc.h"
  3.  
  4.  
  5. extern ddef_t        globals[MAX_GLOBALS];
  6. extern int            numglobaldefs;
  7. extern ddef_t        fields[MAX_FIELDS];
  8. extern int            numfielddefs;
  9.  
  10.  
  11. pr_info_t    pr;
  12. def_t        *pr_global_defs[MAX_REGS];    // to find def for a global variable
  13. int            pr_edict_size;
  14.  
  15. //========================================
  16.  
  17. def_t        *pr_scope;        // the function being parsed, or NULL
  18. boolean    pr_dumpasm;
  19. string_t    s_file;            // filename for function definition
  20.  
  21. int            locals_end;        // for tracking local variables vs temps
  22.  
  23. jmp_buf        pr_parse_abort;        // longjump with this on parse error
  24.  
  25. void PR_ParseDefs (void);
  26.  
  27. //========================================
  28.  
  29.  
  30. opcode_t pr_opcodes[] =
  31. {
  32.  {"<DONE>", "DONE", -1, false, &def_entity, &def_field, &def_void},
  33.  
  34.  {"*", "MUL_F", 2, false, &def_float, &def_float, &def_float},
  35.  {"*", "MUL_V", 2, false, &def_vector, &def_vector, &def_float},
  36.  {"*", "MUL_FV", 2, false, &def_float, &def_vector, &def_vector},
  37.  {"*", "MUL_VF", 2, false, &def_vector, &def_float, &def_vector},
  38.  
  39.  {"/", "DIV", 2, false, &def_float, &def_float, &def_float},
  40.  
  41.  {"+", "ADD_F", 3, false, &def_float, &def_float, &def_float},
  42.  {"+", "ADD_V", 3, false, &def_vector, &def_vector, &def_vector},
  43.  
  44.  {"-", "SUB_F", 3, false, &def_float, &def_float, &def_float},
  45.  {"-", "SUB_V", 3, false, &def_vector, &def_vector, &def_vector},
  46.  
  47.  {"==", "EQ_F", 4, false, &def_float, &def_float, &def_float},
  48.  {"==", "EQ_V", 4, false, &def_vector, &def_vector, &def_float},
  49.  {"==", "EQ_S", 4, false, &def_string, &def_string, &def_float},
  50.  {"==", "EQ_E", 4, false, &def_entity, &def_entity, &def_float},
  51.  {"==", "EQ_FNC", 4, false, &def_function, &def_function, &def_float},
  52.  
  53.  {"!=", "NE_F", 4, false, &def_float, &def_float, &def_float},
  54.  {"!=", "NE_V", 4, false, &def_vector, &def_vector, &def_float},
  55.  {"!=", "NE_S", 4, false, &def_string, &def_string, &def_float},
  56.  {"!=", "NE_E", 4, false, &def_entity, &def_entity, &def_float},
  57.  {"!=", "NE_FNC", 4, false, &def_function, &def_function, &def_float},
  58.  
  59.  {"<=", "LE", 4, false, &def_float, &def_float, &def_float},
  60.  {">=", "GE", 4, false, &def_float, &def_float, &def_float},
  61.  {"<", "LT", 4, false, &def_float, &def_float, &def_float},
  62.  {">", "GT", 4, false, &def_float, &def_float, &def_float},
  63.  
  64.  {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_float},
  65.  {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_vector},
  66.  {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_string},
  67.  {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_entity},
  68.  {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_field},
  69.  {".", "INDIRECT", 1, false, &def_entity, &def_field, &def_function},
  70.  
  71.  {".", "ADDRESS", 1, false, &def_entity, &def_field, &def_pointer},
  72.  
  73.  {"=", "STORE_F", 5, true, &def_float, &def_float, &def_float},
  74.  {"=", "STORE_V", 5, true, &def_vector, &def_vector, &def_vector},
  75.  {"=", "STORE_S", 5, true, &def_string, &def_string, &def_string},
  76.  {"=", "STORE_ENT", 5, true, &def_entity, &def_entity, &def_entity},
  77.  {"=", "STORE_FLD", 5, true, &def_field, &def_field, &def_field},
  78.  {"=", "STORE_FNC", 5, true, &def_function, &def_function, &def_function},
  79.  
  80.  {"=", "STOREP_F", 5, true, &def_pointer, &def_float, &def_float},
  81.  {"=", "STOREP_V", 5, true, &def_pointer, &def_vector, &def_vector},
  82.  {"=", "STOREP_S", 5, true, &def_pointer, &def_string, &def_string},
  83.  {"=", "STOREP_ENT", 5, true, &def_pointer, &def_entity, &def_entity},
  84.  {"=", "STOREP_FLD", 5, true, &def_pointer, &def_field, &def_field},
  85.  {"=", "STOREP_FNC", 5, true, &def_pointer, &def_function, &def_function},
  86.  
  87.  {"<RETURN>", "RETURN", -1, false, &def_void, &def_void, &def_void},
  88.   
  89.  {"!", "NOT_F", -1, false, &def_float, &def_void, &def_float},
  90.  {"!", "NOT_V", -1, false, &def_vector, &def_void, &def_float},
  91.  {"!", "NOT_S", -1, false, &def_vector, &def_void, &def_float},
  92.  {"!", "NOT_ENT", -1, false, &def_entity, &def_void, &def_float},
  93.  {"!", "NOT_FNC", -1, false, &def_function, &def_void, &def_float},
  94.   
  95.   {"<IF>", "IF", -1, false, &def_float, &def_float, &def_void},
  96.   {"<IFNOT>", "IFNOT", -1, false, &def_float, &def_float, &def_void},
  97.  
  98. // calls returns REG_RETURN
  99.  {"<CALL0>", "CALL0", -1, false, &def_function, &def_void, &def_void},
  100.  {"<CALL1>", "CALL1", -1, false, &def_function, &def_void, &def_void},
  101.  {"<CALL2>", "CALL2", -1, false, &def_function, &def_void, &def_void}, 
  102.  {"<CALL3>", "CALL3", -1, false, &def_function, &def_void, &def_void}, 
  103.  {"<CALL4>", "CALL4", -1, false, &def_function, &def_void, &def_void},
  104.  {"<CALL5>", "CALL5", -1, false, &def_function, &def_void, &def_void},
  105.  {"<CALL6>", "CALL6", -1, false, &def_function, &def_void, &def_void},
  106.  {"<CALL7>", "CALL7", -1, false, &def_function, &def_void, &def_void},
  107.  {"<CALL8>", "CALL8", -1, false, &def_function, &def_void, &def_void},
  108.   
  109.  {"<STATE>", "STATE", -1, false, &def_float, &def_float, &def_void},
  110.   
  111.  {"<GOTO>", "GOTO", -1, false, &def_float, &def_void, &def_void},
  112.   
  113.  {"&&", "AND", 6, false, &def_float, &def_float, &def_float},
  114.  {"||", "OR", 6, false, &def_float, &def_float, &def_float},
  115.  
  116.  {"&", "BITAND", 2, false, &def_float, &def_float, &def_float},
  117.  {"|", "BITOR", 2, false, &def_float, &def_float, &def_float},
  118.  
  119.  {NULL}
  120. };
  121.  
  122. #define    TOP_PRIORITY    6
  123. #define    NOT_PRIORITY    4
  124.  
  125. def_t *PR_Expression (int priority);
  126.  
  127. def_t    junkdef;
  128.  
  129. //===========================================================================
  130.  
  131.  
  132. /*
  133. ============
  134. PR_Statement
  135.  
  136. Emits a primitive statement, returning the var it places it's value in
  137. ============
  138. */
  139. def_t *PR_Statement ( opcode_t *op, def_t *var_a, def_t *var_b)
  140. {
  141.     dstatement_t    *statement;
  142.     def_t            *var_c;
  143.     
  144.     statement = &statements[numstatements];
  145.     numstatements++;
  146.  
  147.     statement_linenums[statement-statements] = pr_source_line;
  148.     statement->op = op - pr_opcodes;
  149.     statement->a = var_a ? var_a->ofs : 0;
  150.     statement->b = var_b ? var_b->ofs : 0;
  151.     if (op->type_c == &def_void || op->right_associative)
  152.     {
  153.         var_c = NULL;
  154.         statement->c = 0;            // ifs, gotos, and assignments
  155.                                     // don't need vars allocated
  156.     }
  157.     else
  158.     {    // allocate result space
  159.         var_c = malloc (sizeof(def_t));
  160.         memset (var_c, 0, sizeof(def_t));
  161.         var_c->ofs = numpr_globals;
  162.         var_c->type = op->type_c->type;
  163.  
  164.         statement->c = numpr_globals;
  165.         numpr_globals += type_size[op->type_c->type->type];
  166.     }
  167.  
  168.     if (op->right_associative)
  169.         return var_a;
  170.     return var_c;
  171. }
  172.  
  173. /*
  174. ============
  175. PR_ParseImmediate
  176.  
  177. Looks for a preexisting constant
  178. ============
  179. */
  180. def_t    *PR_ParseImmediate (void)
  181. {
  182.     def_t    *cn;
  183.  
  184. // check for a constant with the same value
  185.     for (cn=pr.def_head; cn; cn=cn->next)
  186.     {
  187.         if (!cn->initialized || cn->type != pr_immediate_type)
  188.             continue;
  189.         if (pr_immediate_type == &type_string)
  190.         {
  191.             if (!strcmp(G_STRING(cn->ofs), pr_immediate_string) )
  192.             {
  193.                 PR_Lex ();
  194.                 return cn;
  195.             }
  196.         }
  197.         else if (pr_immediate_type == &type_float)
  198.         {
  199.             if ( G_FLOAT(cn->ofs) == pr_immediate._float )
  200.             {
  201.                 PR_Lex ();
  202.                 return cn;
  203.             }
  204.         }
  205.         else if    (pr_immediate_type == &type_vector)
  206.         {
  207.             if ( ( G_FLOAT(cn->ofs) == pr_immediate.vector[0] )
  208.             && ( G_FLOAT(cn->ofs+1) == pr_immediate.vector[1] )
  209.             && ( G_FLOAT(cn->ofs+2) == pr_immediate.vector[2] ) )
  210.             {
  211.                 PR_Lex ();
  212.                 return cn;
  213.             }
  214.         }
  215.         else
  216.             PR_ParseError ("weird immediate type");
  217.     }
  218.  
  219. // allocate a new one
  220.     cn = malloc (sizeof(def_t));
  221.     cn->next = pr.def_head;
  222.    pr.def_head = cn;
  223.     cn->type = pr_immediate_type;
  224.     cn->name = "IMMEDIATE";
  225.     cn->initialized = 1;
  226.     cn->scope = NULL;        // always share immediates
  227.  
  228. // copy the immediate to the global area
  229.     cn->ofs = numpr_globals;
  230.     pr_global_defs[cn->ofs] = cn;
  231.     numpr_globals += type_size[pr_immediate_type->type];
  232.     if (pr_immediate_type == &type_string)
  233.         pr_immediate.string = CopyString (pr_immediate_string);
  234.  
  235.     memcpy (pr_globals + cn->ofs, &pr_immediate, 4*type_size[pr_immediate_type->type]);
  236.  
  237.     PR_Lex ();
  238.  
  239.     return cn;
  240. }
  241.  
  242.  
  243. void PrecacheSound (def_t *e, int ch)
  244. {
  245.     char    *n;
  246.     int        i;
  247.     
  248.     if (!e->ofs)
  249.         return;
  250.     n = G_STRING(e->ofs);
  251.     for (i=0 ; i<numsounds ; i++)
  252.         if (!strcmp(n, precache_sounds[i]))
  253.             return;
  254.     if (numsounds == MAX_SOUNDS)
  255.         Error ("PrecacheSound: numsounds == MAX_SOUNDS");
  256.     strcpy (precache_sounds[i], n);
  257.     if (ch >= '1'  && ch <= '9')
  258.         precache_sounds_block[i] = ch - '0';
  259.     else
  260.         precache_sounds_block[i] = 1;
  261.     numsounds++;
  262. }
  263.  
  264. void PrecacheModel (def_t *e, int ch)
  265. {
  266.     char    *n;
  267.     int        i;
  268.     
  269.     if (!e->ofs)
  270.         return;
  271.     n = G_STRING(e->ofs);
  272.     for (i=0 ; i<nummodels ; i++)
  273.         if (!strcmp(n, precache_models[i]))
  274.             return;
  275.     if (numsounds == MAX_SOUNDS)
  276.         Error ("PrecacheModels: numsounds == MAX_SOUNDS");
  277.     strcpy (precache_models[i], n);
  278.     if (ch >= '1'  && ch <= '9')
  279.         precache_models_block[i] = ch - '0';
  280.     else
  281.         precache_models_block[i] = 1;
  282.     nummodels++;
  283. }
  284.  
  285. void PrecacheFile (def_t *e, int ch)
  286. {
  287.     char    *n;
  288.     int        i;
  289.     
  290.     if (!e->ofs)
  291.         return;
  292.     n = G_STRING(e->ofs);
  293.     for (i=0 ; i<numfiles ; i++)
  294.         if (!strcmp(n, precache_files[i]))
  295.             return;
  296.     if (numfiles == MAX_FILES)
  297.         Error ("PrecacheFile: numfiles == MAX_FILES");
  298.     strcpy (precache_files[i], n);
  299.     if (ch >= '1'  && ch <= '9')
  300.         precache_files_block[i] = ch - '0';
  301.     else
  302.         precache_files_block[i] = 1;
  303.     numfiles++;
  304. }
  305.  
  306. /*
  307. ============
  308. PR_ParseFunctionCall
  309. ============
  310. */
  311. def_t *PR_ParseFunctionCall (def_t *func)
  312. {
  313.     def_t        *e;
  314.     int            arg;
  315.     type_t        *t;
  316.     
  317.     t = func->type;
  318.  
  319.     if (t->type != ev_function)
  320.         PR_ParseError ("not a function");
  321.     
  322. // copy the arguments to the global parameter variables
  323.     arg = 0;
  324.     if (!PR_Check(")"))
  325.     {
  326.         do
  327.         {
  328.             if (t->num_parms != -1 && arg >= t->num_parms)
  329.                 PR_ParseError ("too many parameters");
  330.             e = PR_Expression (TOP_PRIORITY);
  331.  
  332.             if (arg == 0 && func->name)
  333.             {
  334.             // save information for model and sound caching
  335.                 if (!strncmp(func->name,"precache_sound", 14))
  336.                     PrecacheSound (e, func->name[14]);
  337.                 else if (!strncmp(func->name,"precache_model", 14))
  338.                     PrecacheModel (e, func->name[14]);
  339.                 else if (!strncmp(func->name,"precache_file", 13))
  340.                     PrecacheFile (e, func->name[13]);
  341.             }
  342.                         
  343.             if (t->num_parms != -1 && ( e->type != t->parm_types[arg] ) )
  344.                 PR_ParseError ("type mismatch on parm %i", arg);
  345.         // a vector copy will copy everything
  346.             def_parms[arg].type = t->parm_types[arg];
  347.             PR_Statement (&pr_opcodes[OP_STORE_V], e, &def_parms[arg]);
  348.             arg++;
  349.         } while (PR_Check (","));
  350.     
  351.         if (t->num_parms != -1 && arg != t->num_parms)
  352.             PR_ParseError ("too few parameters");
  353.         PR_Expect (")");
  354.     }
  355.     if (arg >8)
  356.         PR_ParseError ("More than eight parameters");
  357.         
  358.  
  359.     PR_Statement (&pr_opcodes[OP_CALL0+arg], func, 0);
  360.     
  361.     def_ret.type = t->aux_type;
  362.     return &def_ret;
  363. }
  364.  
  365. /*
  366. ============
  367. PR_ParseValue
  368.  
  369. Returns the global ofs for the current token
  370. ============
  371. */
  372. def_t    *PR_ParseValue (void)
  373. {
  374.     def_t        *d;
  375.     char        *name;
  376.     
  377. // if the token is an immediate, allocate a constant for it
  378.     if (pr_token_type == tt_immediate)
  379.         return PR_ParseImmediate ();
  380.     
  381.     name = PR_ParseName ();
  382.     
  383. // look through the defs
  384.     d = PR_GetDef(NULL, name, pr_scope, false);
  385.     if (!d)
  386.         PR_ParseError ("Unknown value \"%s\"", name);
  387.     return d;
  388. }
  389.  
  390.  
  391. /*
  392. ============
  393. PR_Term
  394. ============
  395. */
  396. def_t *PR_Term (void)
  397. {
  398.     def_t    *e, *e2;
  399.     etype_t    t;
  400.     
  401.     if (PR_Check ("!"))
  402.     {
  403.         e = PR_Expression (NOT_PRIORITY);
  404.         t = e->type->type;
  405.         if (t == ev_float)
  406.             e2 = PR_Statement (&pr_opcodes[OP_NOT_F], e, 0);
  407.         else if (t == ev_string)
  408.             e2 = PR_Statement (&pr_opcodes[OP_NOT_S], e, 0);
  409.         else if (t == ev_entity)
  410.             e2 = PR_Statement (&pr_opcodes[OP_NOT_ENT], e, 0);
  411.         else if (t == ev_vector)
  412.             e2 = PR_Statement (&pr_opcodes[OP_NOT_V], e, 0);
  413.         else if (t == ev_function)
  414.             e2 = PR_Statement (&pr_opcodes[OP_NOT_FNC], e, 0);
  415.         else
  416.         {
  417.             e2 = NULL;        // shut up compiler warning;
  418.             PR_ParseError ("type mismatch for !");
  419.         }
  420.         return e2;
  421.     }
  422.     
  423.     if (PR_Check ("("))
  424.     {
  425.         e = PR_Expression (TOP_PRIORITY);
  426.         PR_Expect (")");
  427.         return e;
  428.     }
  429.     
  430.     return PR_ParseValue ();
  431. }
  432.  
  433. /*
  434. ==============
  435. PR_Expression
  436. ==============
  437. */
  438.  
  439. def_t *PR_Expression (int priority)
  440. {
  441.     opcode_t    *op, *oldop;
  442.     def_t        *e, *e2;
  443.     etype_t        type_a, type_b, type_c;
  444.     
  445.     if (priority == 0)
  446.         return PR_Term ();
  447.         
  448.     e = PR_Expression (priority-1);
  449.         
  450.     while (1)
  451.     {
  452.         if (priority == 1 && PR_Check ("(") )
  453.             return PR_ParseFunctionCall (e);
  454.  
  455.         for (op=pr_opcodes ; op->name ; op++)
  456.         {
  457.             if (op->priority != priority || !PR_Check(op->name))
  458.                 continue;
  459.             if ( op->right_associative )
  460.             {
  461.             // if last statement is an indirect, change it to an address of
  462.                 if ( (unsigned)(statements[numstatements-1].op - OP_LOAD_F) < 6 )
  463.                 {
  464.                     statements[numstatements-1].op = OP_ADDRESS;
  465.                     def_pointer.type->aux_type = e->type;
  466.                     e->type = def_pointer.type;
  467.                 }
  468.                 e2 = PR_Expression (priority);
  469.             }
  470.             else
  471.                 e2 = PR_Expression (priority-1);
  472.                 
  473.         // type check
  474.             type_a = e->type->type;
  475.             type_b = e2->type->type;
  476.  
  477.             if (op->name[0] == '.')// field access gets type from field
  478.             {
  479.                 if (e2->type->aux_type)
  480.                     type_c = e2->type->aux_type->type;
  481.                 else
  482.                     type_c = -1;    // not a field
  483.             }
  484.             else
  485.                 type_c = ev_void;
  486.                 
  487.             oldop = op;
  488.             while (type_a != op->type_a->type->type
  489.             || type_b != op->type_b->type->type
  490.             || (type_c != ev_void && type_c != op->type_c->type->type) )
  491.             {
  492.                 op++;
  493.             if (!op->name || DefCmp(op->name , oldop->name))
  494.                     PR_ParseError ("type mismatch for %s", oldop->name);
  495.             }
  496.  
  497.             if (type_a == ev_pointer && type_b != e->type->aux_type->type)
  498.                 PR_ParseError ("type mismatch for %s", op->name);
  499.  
  500.  
  501.             if (op->right_associative)
  502.                 e = PR_Statement (op, e2, e);
  503.             else
  504.                 e = PR_Statement (op, e, e2);
  505.             
  506.             if (type_c != ev_void)    // field access gets type from field
  507.                 e->type = e2->type->aux_type;
  508.             
  509.             break;
  510.         }
  511.         if (!op->name)
  512.             break;    // next token isn't at this priority level
  513.     }
  514.     
  515.     return e;
  516. }
  517.  
  518.  
  519. /*
  520. ============
  521. PR_ParseStatement
  522.  
  523. ============
  524. */
  525. void PR_ParseStatement (void)
  526. {
  527.     def_t                *e;
  528.     dstatement_t        *patch1, *patch2;
  529.     
  530.     if (PR_Check ("{"))
  531.     {
  532.         do
  533.         {
  534.             PR_ParseStatement ();
  535.         } while (!PR_Check ("}"));
  536.         return;
  537.     }
  538.     
  539.     if (PR_Check("return"))
  540.     {
  541.         if (PR_Check (";"))
  542.         {
  543.             PR_Statement (&pr_opcodes[OP_RETURN], 0, 0);
  544.             return;
  545.         }
  546.         e = PR_Expression (TOP_PRIORITY);
  547.         PR_Expect (";");
  548.         PR_Statement (&pr_opcodes[OP_RETURN], e, 0);
  549.         return;        
  550.     }
  551.     
  552.     if (PR_Check("while"))
  553.     {
  554.         PR_Expect ("(");
  555.         patch2 = &statements[numstatements];
  556.         e = PR_Expression (TOP_PRIORITY);
  557.         PR_Expect (")");
  558.         patch1 = &statements[numstatements];
  559.         PR_Statement (&pr_opcodes[OP_IFNOT], e, 0);
  560.         PR_ParseStatement ();
  561.         junkdef.ofs = patch2 - &statements[numstatements];
  562.         PR_Statement (&pr_opcodes[OP_GOTO], &junkdef, 0);
  563.         patch1->b = &statements[numstatements] - patch1;
  564.         return;
  565.     }
  566.     
  567.     if (PR_Check("do"))
  568.     {
  569.         patch1 = &statements[numstatements];
  570.         PR_ParseStatement ();
  571.         PR_Expect ("while");
  572.         PR_Expect ("(");
  573.         e = PR_Expression (TOP_PRIORITY);
  574.         PR_Expect (")");
  575.         PR_Expect (";");
  576.         junkdef.ofs = patch1 - &statements[numstatements];
  577.         PR_Statement (&pr_opcodes[OP_IF], e, &junkdef);
  578.         return;
  579.     }
  580.     
  581.     if (PR_Check("local"))
  582.     {
  583.         PR_ParseDefs ();
  584.         locals_end = numpr_globals;
  585.         return;
  586.     }
  587.     
  588.     if (PR_Check("if"))
  589.     {
  590.         PR_Expect ("(");
  591.         e = PR_Expression (TOP_PRIORITY);
  592.         PR_Expect (")");
  593.         
  594.         patch1 = &statements[numstatements];
  595.         PR_Statement (&pr_opcodes[OP_IFNOT], e, 0);
  596.         
  597.         PR_ParseStatement ();
  598.         
  599.         if (PR_Check ("else"))
  600.         {
  601.             patch2 = &statements[numstatements];
  602.             PR_Statement (&pr_opcodes[OP_GOTO], 0, 0);
  603.             patch1->b = &statements[numstatements] - patch1;
  604.             PR_ParseStatement ();
  605.             patch2->a = &statements[numstatements] - patch2;
  606.         }
  607.         else
  608.             patch1->b = &statements[numstatements] - patch1;
  609.         
  610.         return;
  611.     }
  612.     
  613.     PR_Expression (TOP_PRIORITY);
  614.     PR_Expect (";");
  615. }
  616.  
  617.  
  618. /*
  619. ==============
  620. PR_ParseState
  621.  
  622. States are special functions made for convenience.  They automatically
  623. set frame, nextthink (implicitly), and think (allowing forward definitions).
  624.  
  625. // void() name = [framenum, nextthink] {code}
  626. // expands to:
  627. // function void name ()
  628. // {
  629. //        self.frame=framenum;
  630. //        self.nextthink = time + 0.1;
  631. //        self.think = nextthink
  632. //        <code>
  633. // };
  634. ==============
  635. */
  636. void PR_ParseState (void)
  637. {
  638.     char    *name;
  639.     def_t    *s1, *def;
  640.  
  641.     if (pr_token_type != tt_immediate || pr_immediate_type != &type_float)
  642.         PR_ParseError ("state frame must be a number");
  643.     s1 = PR_ParseImmediate ();
  644.  
  645.     PR_Expect (",");
  646.  
  647.     name = PR_ParseName ();
  648.     def = PR_GetDef (&type_function, name,0, true);
  649.  
  650.     PR_Expect ("]");
  651.  
  652.     PR_Statement (&pr_opcodes[OP_STATE], s1, def);
  653. }
  654.  
  655. /*
  656. ============
  657. PR_ParseImmediateStatements
  658.  
  659. Parse a function body
  660. ============
  661. */
  662. function_t *PR_ParseImmediateStatements (type_t *type)
  663. {
  664.     int            i;
  665.     function_t    *f;
  666.     def_t        *defs[MAX_PARMS];
  667.     
  668.     f = malloc (sizeof(function_t));
  669.  
  670. //
  671. // check for builtin function definition #1, #2, etc
  672. //
  673.     if (PR_Check ("#"))
  674.     {
  675.         if (pr_token_type != tt_immediate
  676.         || pr_immediate_type != &type_float
  677.         || pr_immediate._float != (int)pr_immediate._float)
  678.             PR_ParseError ("Bad builtin immediate");
  679.         f->builtin = (int)pr_immediate._float;
  680.         PR_Lex ();
  681.         return f;
  682.     }
  683.     
  684.     f->builtin = 0;
  685. //
  686. // define the parms
  687. //
  688.     for (i=0 ; i<type->num_parms ; i++)
  689.     {
  690.         defs[i] = PR_GetDef (type->parm_types[i], pr_parm_names[i], pr_scope, true);
  691.         f->parm_ofs[i] = defs[i]->ofs;
  692.         if (i > 0 && f->parm_ofs[i] < f->parm_ofs[i-1])
  693.             Error ("bad parm order");
  694.     }
  695.     
  696.     f->code = numstatements;
  697.  
  698. //
  699. // check for a state opcode
  700. //
  701.     if (PR_Check ("["))
  702.         PR_ParseState ();
  703.         
  704. //
  705. // parse regular statements
  706. //
  707.     PR_Expect ("{");
  708.  
  709.     while (!PR_Check("}"))
  710.         PR_ParseStatement ();
  711.  
  712. // emit an end of statements opcode
  713.     PR_Statement (pr_opcodes, 0,0);
  714.  
  715.  
  716.     return f;
  717. }
  718.  
  719.  
  720. /*
  721. ============
  722. PR_GetDef
  723.  
  724. If type is NULL, it will match any type
  725. If allocate is true, a new def will be allocated if it can't be found
  726. ============
  727. */
  728. def_t *PR_GetDef (type_t *type, char *name, def_t *scope, boolean allocate)
  729. {
  730.     def_t    *def, *prevdef;
  731.    int len;
  732.     char element[MAX_NAME];
  733.  
  734. // see if the name is already in use
  735.     for (prevdef = NULL, def = pr.def_head; def
  736.       ; prevdef = def, def = def->next)
  737.    {
  738.         if (!DefCmp(def->name,name) )
  739.         {
  740.             if ( def->scope && def->scope != scope)
  741.                 continue;    // in a different function
  742.  
  743.             if (type && def->type != type)
  744.                 PR_ParseError ("Type mismatch on redeclaration of %s",name);
  745.  
  746.             if (prevdef)
  747.          {
  748.                 prevdef->next = def->next;
  749.                 def->next = pr.def_head;
  750.               pr.def_head = def;
  751.          }
  752.             return def;
  753.         }
  754.     }
  755.  
  756.     if (!allocate)
  757.         return NULL;
  758.  
  759. // allocate a new def
  760.    len = strlen(name) + 1;
  761.     def = malloc (sizeof(def_t) + len);
  762.     def->next = pr.def_head;
  763.     pr.def_head = def;
  764.     def->name = (char *)def + sizeof(def_t);
  765.     memcpy (def->name, name, len);
  766.     def->type = type;
  767.    def->initialized = 0;
  768.    def->scope = scope;
  769.     def->ofs = numpr_globals;
  770.     pr_global_defs[numpr_globals] = def;
  771.  
  772. //
  773. // make automatic defs for the vectors elements
  774. // .origin can be accessed as .origin_x, .origin_y, and .origin_z
  775. //
  776.     if (type->type == ev_vector)
  777.     {
  778.         sprintf (element, "%s_x",name);
  779.         PR_GetDef (&type_float, element, scope, true);
  780.  
  781.         sprintf (element, "%s_y",name);
  782.         PR_GetDef (&type_float, element, scope, true);
  783.  
  784.         sprintf (element, "%s_z",name);
  785.         PR_GetDef (&type_float, element, scope, true);
  786.     }
  787.     else
  788.         numpr_globals += type_size[type->type];
  789.  
  790.     if (type->type == ev_field)
  791.     {
  792.         *(int *)&pr_globals[def->ofs] = pr.size_fields;
  793.         
  794.         if (type->aux_type->type == ev_vector)
  795.         {
  796.             sprintf (element, "%s_x",name);
  797.             PR_GetDef (&type_floatfield, element, scope, true);
  798.             
  799.             sprintf (element, "%s_y",name);
  800.             PR_GetDef (&type_floatfield, element, scope, true);
  801.             
  802.             sprintf (element, "%s_z",name);
  803.             PR_GetDef (&type_floatfield, element, scope, true);
  804.         }
  805.         else
  806.             pr.size_fields += type_size[type->aux_type->type];
  807.     }
  808.  
  809. //    if (pr_dumpasm)
  810. //        PR_PrintOfs (def->ofs);
  811.  
  812.     return def;
  813. }
  814.  
  815.  
  816. /*
  817. ================
  818. PR_ParseDefs
  819.  
  820. Called at the outer layer and when a local statement is hit
  821. ================
  822. */
  823. void PR_ParseDefs (void)
  824. {
  825.     char        *name;
  826.     type_t    *type;
  827.     def_t        *def;
  828.     function_t    *f;
  829.     dfunction_t    *df;
  830.     int            i;
  831.     int            locals_start;
  832.  
  833.     type = PR_ParseType ();
  834.     
  835.     if (pr_scope && (type->type == ev_field || type->type == ev_function) )
  836.         PR_ParseError ("Fields and functions must be global");
  837.         
  838.     do
  839.     {
  840.         name = PR_ParseName ();
  841.  
  842.         def = PR_GetDef (type, name, pr_scope, true);
  843.  
  844. // check for an initialization
  845.         if ( PR_Check ("=") )
  846.         {
  847.             if (def->initialized)
  848.                 PR_ParseError ("%s redeclared", name);
  849.     
  850.             if (type->type == ev_function)
  851.             {
  852.                 locals_start = locals_end = numpr_globals;
  853.                 pr_scope = def;
  854.                 f = PR_ParseImmediateStatements (type);
  855.                 pr_scope = NULL;
  856.                 def->initialized = 1;
  857.                 G_FUNCTION(def->ofs) = numfunctions;
  858.                 f->def = def;
  859. //                if (pr_dumpasm)
  860. //                    PR_PrintFunction (def);
  861.  
  862.         // fill in the dfunction
  863.                 df = &functions[numfunctions];
  864.                 numfunctions++;
  865.                 if (f->builtin)
  866.                     df->first_statement = -f->builtin;
  867.                 else
  868.                     df->first_statement = f->code;
  869.                 df->s_name = CopyString (f->def->name);
  870.                 df->s_file = s_file;
  871.                 df->numparms =  f->def->type->num_parms;
  872.                 df->locals = locals_end - locals_start;
  873.                 df->parm_start = locals_start;
  874.                 for (i=0 ; i<df->numparms ; i++)
  875.                     df->parm_size[i] = type_size[f->def->type->parm_types[i]->type];
  876.                 
  877.                 continue;
  878.             }
  879.             else if (pr_immediate_type != type)
  880.                 PR_ParseError ("wrong immediate type for %s", name);
  881.     
  882.             def->initialized = 1;
  883.             memcpy (pr_globals + def->ofs, &pr_immediate, 4*type_size[pr_immediate_type->type]);
  884.             PR_Lex ();
  885.         }
  886.         
  887.     } while (PR_Check (","));
  888.  
  889.     PR_Expect (";");
  890. }
  891.  
  892. /*
  893. ============
  894. PR_CompileFile
  895.  
  896. compiles the 0 terminated text, adding defintions to the pr structure
  897. ============
  898. */
  899. boolean    PR_CompileFile (char *string, char *filename)
  900. {    
  901.     if (!pr.memory)
  902.         Error ("PR_CompileFile: Didn't clear");
  903.  
  904.     PR_ClearGrabMacros ();    // clear the frame macros
  905.  
  906.     pr_file_p = string;
  907.     s_file = CopyString (filename);
  908.  
  909.     pr_source_line = 0;
  910.  
  911.     PR_NewLine ();
  912.  
  913.     PR_Lex ();    // read first token
  914.  
  915.     while (pr_token_type != tt_eof)
  916.     {
  917.         if (setjmp(pr_parse_abort))
  918.         {
  919.             if (++pr_error_count > MAX_ERRORS)
  920.                 return false;
  921.             PR_SkipToSemicolon ();
  922.             if (pr_token_type == tt_eof)
  923.                 return false;
  924.         }
  925.  
  926.         pr_scope = NULL;    // outside all functions
  927.  
  928.         PR_ParseDefs ();
  929.     }
  930.  
  931.     return (pr_error_count == 0);
  932. }
  933.  
  934.